/*
 *  Copyright (c) 2012 Brandon Ellenberger
 *
 *  This file is part of OpSatPlan.
 *
 *  OpSatPlan is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  OpSatPlan is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with OpSatPlan.  If not, see <http://www.gnu.org/licenses/>.
 */
namespace OpSatPlan.LexerParser
{
    using TUVienna.CS_CUP.Runtime;
    using System;


    class PddlLexer : TUVienna.CS_CUP.Runtime.Scanner
    {
        private const int YY_BUFFER_SIZE = 512;
        private const int YY_F = -1;
        private const int YY_NO_STATE = -1;
        private const int YY_NOT_ACCEPT = 0;
        private const int YY_START = 1;
        private const int YY_END = 2;
        private const int YY_NO_ANCHOR = 4;
        private const int YY_BOL = 128;
        private const int YY_EOF = 129;
        private System.IO.TextReader yy_reader;
        private int yy_buffer_index;
        private int yy_buffer_read;
        private int yy_buffer_start;
        private int yy_buffer_end;
        private char[] yy_buffer;
        private bool yy_at_bol;
        private int yy_lexical_state;

        public PddlLexer(System.IO.TextReader yy_reader1)
            : this()
        {
            if (null == yy_reader1)
            {
                throw (new System.Exception("Error: Bad input stream initializer."));
            }
            yy_reader = yy_reader1;
        }

        private PddlLexer()
        {
            yy_buffer = new char[YY_BUFFER_SIZE];
            yy_buffer_read = 0;
            yy_buffer_index = 0;
            yy_buffer_start = 0;
            yy_buffer_end = 0;
            yy_at_bol = true;
            yy_lexical_state = YYINITIAL;

            Position.reset();
        }

        private bool yy_eof_done = false;
        private const int YYINITIAL = 0;
        private static readonly int[] yy_state_dtrans = new int[] {
		0
	};
        private void yybegin(int state)
        {
            yy_lexical_state = state;
        }
        private int yy_advance()
        {
            int next_read;
            int i;
            int j;

            if (yy_buffer_index < yy_buffer_read)
            {
                return yy_buffer[yy_buffer_index++];
            }

            if (0 != yy_buffer_start)
            {
                i = yy_buffer_start;
                j = 0;
                while (i < yy_buffer_read)
                {
                    yy_buffer[j] = yy_buffer[i];
                    ++i;
                    ++j;
                }
                yy_buffer_end = yy_buffer_end - yy_buffer_start;
                yy_buffer_start = 0;
                yy_buffer_read = j;
                yy_buffer_index = j;
                next_read = yy_reader.Read(yy_buffer,
                        yy_buffer_read,
                        yy_buffer.Length - yy_buffer_read);
                if (next_read <= 0)
                {
                    return YY_EOF;
                }
                yy_buffer_read = yy_buffer_read + next_read;
            }

            while (yy_buffer_index >= yy_buffer_read)
            {
                if (yy_buffer_index >= yy_buffer.Length)
                {
                    yy_buffer = yy_double(yy_buffer);
                }
                next_read = yy_reader.Read(yy_buffer,
                        yy_buffer_read,
                        yy_buffer.Length - yy_buffer_read);
                if (next_read <= 0)
                {
                    return YY_EOF;
                }
                yy_buffer_read = yy_buffer_read + next_read;
            }
            return yy_buffer[yy_buffer_index++];
        }
        private void yy_move_end()
        {
            if (yy_buffer_end > yy_buffer_start &&
                '\n' == yy_buffer[yy_buffer_end - 1])
                yy_buffer_end--;
            if (yy_buffer_end > yy_buffer_start &&
                '\r' == yy_buffer[yy_buffer_end - 1])
                yy_buffer_end--;
        }
        private bool yy_last_was_cr = false;
        private void yy_mark_start()
        {
            yy_buffer_start = yy_buffer_index;
        }
        private void yy_mark_end()
        {
            yy_buffer_end = yy_buffer_index;
        }
        private void yy_to_mark()
        {
            yy_buffer_index = yy_buffer_end;
            yy_at_bol = (yy_buffer_end > yy_buffer_start) &&
                        ('\r' == yy_buffer[yy_buffer_end - 1] ||
                         '\n' == yy_buffer[yy_buffer_end - 1] ||
                         2028/*LS*/ == yy_buffer[yy_buffer_end - 1] ||
                         2029/*PS*/ == yy_buffer[yy_buffer_end - 1]);
        }
        private string yytext()
        {
            return (new string(yy_buffer,
                yy_buffer_start,
                yy_buffer_end - yy_buffer_start));
        }
        private int yylength()
        {
            return yy_buffer_end - yy_buffer_start;
        }
        private char[] yy_double(char[] buf)
        {
            int i;
            char[] newbuf;
            newbuf = new char[2 * buf.Length];
            for (i = 0; i < buf.Length; ++i)
            {
                newbuf[i] = buf[i];
            }
            return newbuf;
        }
        private const int YY_E_INTERNAL = 0;
        private const int YY_E_MATCH = 1;
        private string[] yy_error_string = {
		"Error: Internal error.\n",
		"Error: Unmatched input.\n"
	};
        private void yy_error(int code, bool fatal)
        {
            System.Console.Write(yy_error_string[code]);
            System.Console.Out.Flush();
            if (fatal)
            {
                throw new System.Exception("Fatal Error.\n");
            }
        }
        private static int[][] unpackFromString(int size1, int size2, string st)
        {
            int colonIndex = -1;
            string lengthString;
            int sequenceLength = 0;
            int sequenceInteger = 0;

            int commaIndex;
            string workString;

            int[][] res = new int[size1][];
            for (int i = 0; i < size1; i++) res[i] = new int[size2];
            for (int i = 0; i < size1; i++)
            {
                for (int j = 0; j < size2; j++)
                {
                    if (sequenceLength != 0)
                    {
                        res[i][j] = sequenceInteger;
                        sequenceLength--;
                        continue;
                    }
                    commaIndex = st.IndexOf(',');
                    workString = (commaIndex == -1) ? st :
                        st.Substring(0, commaIndex);
                    st = st.Substring(commaIndex + 1);
                    colonIndex = workString.IndexOf(':');
                    if (colonIndex == -1)
                    {
                        res[i][j] = System.Int32.Parse(workString);
                        continue;
                    }
                    lengthString =
                        workString.Substring(colonIndex + 1);
                    sequenceLength = System.Int32.Parse(lengthString);
                    workString = workString.Substring(0, colonIndex);
                    sequenceInteger = System.Int32.Parse(workString);
                    res[i][j] = sequenceInteger;
                    sequenceLength--;
                }
            }
            return res;
        }
        private int[] yy_acpt = {
		/* 0 */ YY_NOT_ACCEPT,
		/* 1 */ YY_NO_ANCHOR,
		/* 2 */ YY_NO_ANCHOR,
		/* 3 */ YY_NO_ANCHOR,
		/* 4 */ YY_NO_ANCHOR,
		/* 5 */ YY_NO_ANCHOR,
		/* 6 */ YY_NO_ANCHOR,
		/* 7 */ YY_NO_ANCHOR,
		/* 8 */ YY_NO_ANCHOR,
		/* 9 */ YY_NO_ANCHOR,
		/* 10 */ YY_NO_ANCHOR,
		/* 11 */ YY_NO_ANCHOR,
		/* 12 */ YY_NO_ANCHOR,
		/* 13 */ YY_NO_ANCHOR,
		/* 14 */ YY_NO_ANCHOR,
		/* 15 */ YY_NO_ANCHOR,
		/* 16 */ YY_NO_ANCHOR,
		/* 17 */ YY_NO_ANCHOR,
		/* 18 */ YY_NO_ANCHOR,
		/* 19 */ YY_NO_ANCHOR,
		/* 20 */ YY_NO_ANCHOR,
		/* 21 */ YY_NO_ANCHOR,
		/* 22 */ YY_NO_ANCHOR,
		/* 23 */ YY_NO_ANCHOR,
		/* 24 */ YY_NO_ANCHOR,
		/* 25 */ YY_NO_ANCHOR,
		/* 26 */ YY_NO_ANCHOR,
		/* 27 */ YY_NO_ANCHOR,
		/* 28 */ YY_NO_ANCHOR,
		/* 29 */ YY_NO_ANCHOR,
		/* 30 */ YY_NO_ANCHOR,
		/* 31 */ YY_NO_ANCHOR,
		/* 32 */ YY_NO_ANCHOR,
		/* 33 */ YY_NOT_ACCEPT,
		/* 34 */ YY_NO_ANCHOR,
		/* 35 */ YY_NO_ANCHOR,
		/* 36 */ YY_NO_ANCHOR,
		/* 37 */ YY_NO_ANCHOR,
		/* 38 */ YY_NO_ANCHOR,
		/* 39 */ YY_NO_ANCHOR,
		/* 40 */ YY_NO_ANCHOR,
		/* 41 */ YY_NO_ANCHOR,
		/* 42 */ YY_NO_ANCHOR,
		/* 43 */ YY_NO_ANCHOR,
		/* 44 */ YY_NO_ANCHOR,
		/* 45 */ YY_NO_ANCHOR,
		/* 46 */ YY_NO_ANCHOR,
		/* 47 */ YY_NO_ANCHOR,
		/* 48 */ YY_NO_ANCHOR,
		/* 49 */ YY_NO_ANCHOR,
		/* 50 */ YY_NO_ANCHOR,
		/* 51 */ YY_NO_ANCHOR,
		/* 52 */ YY_NO_ANCHOR,
		/* 53 */ YY_NO_ANCHOR,
		/* 54 */ YY_NO_ANCHOR,
		/* 55 */ YY_NO_ANCHOR,
		/* 56 */ YY_NO_ANCHOR,
		/* 57 */ YY_NO_ANCHOR,
		/* 58 */ YY_NO_ANCHOR,
		/* 59 */ YY_NO_ANCHOR,
		/* 60 */ YY_NO_ANCHOR,
		/* 61 */ YY_NO_ANCHOR,
		/* 62 */ YY_NO_ANCHOR,
		/* 63 */ YY_NO_ANCHOR,
		/* 64 */ YY_NO_ANCHOR,
		/* 65 */ YY_NO_ANCHOR,
		/* 66 */ YY_NO_ANCHOR,
		/* 67 */ YY_NO_ANCHOR,
		/* 68 */ YY_NO_ANCHOR,
		/* 69 */ YY_NO_ANCHOR,
		/* 70 */ YY_NO_ANCHOR,
		/* 71 */ YY_NO_ANCHOR,
		/* 72 */ YY_NO_ANCHOR,
		/* 73 */ YY_NO_ANCHOR,
		/* 74 */ YY_NO_ANCHOR,
		/* 75 */ YY_NO_ANCHOR,
		/* 76 */ YY_NO_ANCHOR,
		/* 77 */ YY_NO_ANCHOR,
		/* 78 */ YY_NO_ANCHOR,
		/* 79 */ YY_NO_ANCHOR,
		/* 80 */ YY_NO_ANCHOR,
		/* 81 */ YY_NO_ANCHOR,
		/* 82 */ YY_NO_ANCHOR,
		/* 83 */ YY_NO_ANCHOR,
		/* 84 */ YY_NO_ANCHOR,
		/* 85 */ YY_NO_ANCHOR,
		/* 86 */ YY_NO_ANCHOR,
		/* 87 */ YY_NO_ANCHOR,
		/* 88 */ YY_NO_ANCHOR,
		/* 89 */ YY_NO_ANCHOR,
		/* 90 */ YY_NO_ANCHOR,
		/* 91 */ YY_NO_ANCHOR,
		/* 92 */ YY_NO_ANCHOR,
		/* 93 */ YY_NO_ANCHOR,
		/* 94 */ YY_NO_ANCHOR,
		/* 95 */ YY_NO_ANCHOR,
		/* 96 */ YY_NO_ANCHOR,
		/* 97 */ YY_NO_ANCHOR,
		/* 98 */ YY_NO_ANCHOR,
		/* 99 */ YY_NO_ANCHOR,
		/* 100 */ YY_NO_ANCHOR,
		/* 101 */ YY_NO_ANCHOR,
		/* 102 */ YY_NO_ANCHOR,
		/* 103 */ YY_NO_ANCHOR,
		/* 104 */ YY_NO_ANCHOR,
		/* 105 */ YY_NO_ANCHOR,
		/* 106 */ YY_NO_ANCHOR,
		/* 107 */ YY_NO_ANCHOR,
		/* 108 */ YY_NO_ANCHOR,
		/* 109 */ YY_NO_ANCHOR,
		/* 110 */ YY_NO_ANCHOR,
		/* 111 */ YY_NO_ANCHOR,
		/* 112 */ YY_NO_ANCHOR,
		/* 113 */ YY_NO_ANCHOR,
		/* 114 */ YY_NO_ANCHOR,
		/* 115 */ YY_NO_ANCHOR,
		/* 116 */ YY_NO_ANCHOR,
		/* 117 */ YY_NO_ANCHOR,
		/* 118 */ YY_NO_ANCHOR,
		/* 119 */ YY_NO_ANCHOR,
		/* 120 */ YY_NO_ANCHOR,
		/* 121 */ YY_NO_ANCHOR,
		/* 122 */ YY_NO_ANCHOR,
		/* 123 */ YY_NO_ANCHOR,
		/* 124 */ YY_NO_ANCHOR,
		/* 125 */ YY_NO_ANCHOR,
		/* 126 */ YY_NO_ANCHOR,
		/* 127 */ YY_NO_ANCHOR,
		/* 128 */ YY_NO_ANCHOR,
		/* 129 */ YY_NO_ANCHOR,
		/* 130 */ YY_NO_ANCHOR,
		/* 131 */ YY_NO_ANCHOR,
		/* 132 */ YY_NO_ANCHOR
	};
        private int[] yy_cmap = unpackFromString(1, 130,
    "5:9,3,2,5:2,1,5:18,3,5:7,6,7,5:3,8,5:2,33:10,9,4,5:3,10,5,18,28,27,11,12,13" +
    ",26,31,14,30,32,29,17,15,16,25,20,19,23,22,21,32:3,24,32,5:4,33,5,18,28,27," +
    "11,12,13,26,31,14,30,32,29,17,15,16,25,20,19,23,22,21,32:3,24,32,5:5,0:2")[0];

        private int[] yy_rmap = unpackFromString(1, 133,
    "0,1:3,2,3,1:5,4,1,5:9,6,5:10,3,1,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21," +
    "22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46," +
    "47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,5,64,65,66,67,68,69,70,7" +
    "1,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,9" +
    "6,97,5,98,99,100,101,102")[0];

        private int[][] yy_nxt = unpackFromString(103, 34,
    "1,2,3,4,5,34,6,7,8,9,10,11,124,127,73,54,129,127,55,130,127:2,89,131,127,13" +
    "2,74,127:6,34,-1:37,4,-1:31,33,12,33:31,-1:8,127,-1:2,127,90,127:3,91,127:1" +
    "6,92,-1:8,127,-1:2,127:22,92,-1:8,127,-1:2,127:12,26,127:9,92,-1:8,127,-1:2" +
    ",127:11,13,127:10,92,-1:8,127,-1:2,14,127:21,92,-1:8,127,-1:2,127:11,15,127" +
    ":10,92,-1:8,127,-1:2,127:18,16,127:3,92,-1:8,127,-1:2,127:12,17,127:9,92,-1" +
    ":8,127,-1:2,127,18,127:20,92,-1:8,127,-1:2,127:4,19,127:17,92,-1:8,127,-1:2" +
    ",127:11,20,127:10,92,-1:8,127,-1:2,127:8,21,127:13,92,-1:8,127,-1:2,127:11," +
    "22,127:10,92,-1:8,127,-1:2,127:4,23,127:17,92,-1:8,127,-1:2,127:15,24,127:6" +
    ",92,-1:8,127,-1:2,127:12,25,127:9,92,-1:8,127,-1:2,127:6,27,127:15,92,-1:8," +
    "127,-1:2,127:12,28,127:9,92,-1:8,127,-1:2,127:12,29,127:9,92,-1:8,127,-1:2," +
    "127:12,30,127:9,92,-1:8,127,-1:2,127:12,31,127:9,92,-1:8,127,-1:2,127:4,32," +
    "127:17,92,-1:8,127,-1:2,127:5,35,127:16,92,-1:8,127,-1:2,127:4,36,127:11,97" +
    ",127:5,92,-1:8,127,-1:2,127:3,37,127:18,92,-1:8,127,-1:2,127:7,38,127:14,92" +
    ",-1:8,127,-1:2,127,39,127,65,127:18,92,-1:8,127,-1:2,127:4,40,127:17,92,-1:" +
    "8,127,-1:2,127:3,41,127:18,92,-1:8,127,-1:2,127:16,42,127:5,92,-1:8,127,-1:" +
    "2,127,43,127:20,92,-1:8,127,-1:2,127:16,44,127:5,92,-1:8,127,-1:2,127:5,45," +
    "127:16,92,-1:8,127,-1:2,127:4,46,127:17,92,-1:8,127,-1:2,127:14,47,127:7,92" +
    ",-1:8,127,-1:2,127,48,127:20,92,-1:8,127,-1:2,127:8,49,127:13,92,-1:8,127,-" +
    "1:2,127,50,127:20,92,-1:8,127,-1:2,127:8,51,127:13,92,-1:8,127,-1:2,127:11," +
    "52,127:10,92,-1:8,127,-1:2,127:5,53,127:16,92,-1:8,127,-1:2,95,127:3,56,127" +
    ":17,92,-1:8,127,-1:2,127:5,57,127:16,92,-1:8,127,-1:2,127:14,58,127:7,92,-1" +
    ":8,127,-1:2,127:3,59,127:18,92,-1:8,127,-1:2,127:7,60,127:14,92,-1:8,127,-1" +
    ":2,127,61,127:20,92,-1:8,127,-1:2,127:20,62,127,92,-1:8,127,-1:2,127,63,127" +
    ":20,92,-1:8,127,-1:2,127:3,64,127:18,92,-1:8,127,-1:2,127:3,66,127:18,92,-1" +
    ":8,127,-1:2,127:18,67,127:3,92,-1:8,127,-1:2,127,68,127:20,92,-1:8,127,-1:2" +
    ",127:11,69,127:10,92,-1:8,127,-1:2,127,70,127:20,92,-1:8,127,-1:2,127:4,71," +
    "127:17,92,-1:8,127,-1:2,127:3,72,127:18,92,-1:8,127,-1:2,127:13,75,127:8,92" +
    ",-1:8,127,-1:2,127:2,76,127:19,92,-1:8,127,-1:2,127:6,77,127:15,92,-1:8,127" +
    ",-1:2,127:2,78,127:19,92,-1:8,127,-1:2,127:11,79,127:10,92,-1:8,127,-1:2,12" +
    "7,102,127:20,92,-1:8,127,-1:2,127:19,80,127:2,92,-1:8,127,-1:2,127:11,81,12" +
    "7:10,92,-1:8,127,-1:2,127:9,103,127:12,92,-1:8,127,-1:2,127:8,82,127:13,92," +
    "-1:8,127,-1:2,127:8,104,127:13,92,-1:8,127,-1:2,127,105,127:3,106,127:16,92" +
    ",-1:8,127,-1:2,127:4,107,127:17,92,-1:8,127,-1:2,127:10,108,127:11,92,-1:8," +
    "127,-1:2,127:7,109,127:14,92,-1:8,127,-1:2,125,127:15,110,127:5,92,-1:8,127" +
    ",-1:2,127:17,83,127:4,92,-1:8,127,-1:2,127:11,128,127:10,92,-1:8,127,-1:2,1" +
    "27:3,111,127:18,92,-1:8,127,-1:2,127:6,112,127:15,92,-1:8,127,-1:2,127:5,11" +
    "4,127:16,92,-1:8,127,-1:2,127:8,126,127:13,92,-1:8,127,-1:2,127,116,127:20," +
    "92,-1:8,127,-1:2,127:16,117,127:5,92,-1:8,127,-1:2,127:4,118,127:17,92,-1:8" +
    ",127,-1:2,127:2,119,127:19,92,-1:8,127,-1:2,127:11,84,127:10,92,-1:8,127,-1" +
    ":2,127:7,85,127:14,92,-1:8,127,-1:2,121,127:21,92,-1:8,127,-1:2,127:3,86,12" +
    "7:18,92,-1:8,127,-1:2,127:6,122,127:15,92,-1:8,127,-1:2,127:3,123,127:18,92" +
    ",-1:8,127,-1:2,127,87,127:20,92,-1:8,127,-1:2,127:11,88,127:10,92,-1:8,127," +
    "-1:2,127:2,93,94,127:18,92,-1:8,127,-1:2,127:3,113,127:18,92,-1:8,127,-1:2," +
    "127,120,127:20,92,-1:8,127,-1:2,127:3,115,127:18,92,-1:8,127,-1:2,127:17,96" +
    ",127:4,92,-1:8,127,-1:2,127,98,127:20,92,-1:8,127,-1:2,127:11,99,127:10,92," +
    "-1:8,127,-1:2,127:7,100,101,127:13,92");

        public TUVienna.CS_CUP.Runtime.Symbol next_token()
        {
            int yy_lookahead;
            int yy_anchor = YY_NO_ANCHOR;
            int yy_state = yy_state_dtrans[yy_lexical_state];
            int yy_next_state = YY_NO_STATE;
            int yy_last_accept_state = YY_NO_STATE;
            bool yy_initial = true;
            int yy_this_accept;

            yy_mark_start();
            yy_this_accept = yy_acpt[yy_state];
            if (YY_NOT_ACCEPT != yy_this_accept)
            {
                yy_last_accept_state = yy_state;
                yy_mark_end();
            }
            while (true)
            {
                if (yy_initial && yy_at_bol) yy_lookahead = YY_BOL;
                else yy_lookahead = yy_advance();
                yy_next_state = YY_F;
                yy_next_state = yy_nxt[yy_rmap[yy_state]][yy_cmap[yy_lookahead]];
                if (YY_EOF == yy_lookahead && true == yy_initial)
                {

                    return new Symbol(sym.EOF, new PddlToken(0, 0));
                }
                if (YY_F != yy_next_state)
                {
                    yy_state = yy_next_state;
                    yy_initial = false;
                    yy_this_accept = yy_acpt[yy_state];
                    if (YY_NOT_ACCEPT != yy_this_accept)
                    {
                        yy_last_accept_state = yy_state;
                        yy_mark_end();
                    }
                }
                else
                {
                    if (YY_NO_STATE == yy_last_accept_state)
                    {
                        throw (new System.Exception("Lexical Error: Unmatched Input."));
                    }
                    else
                    {
                        yy_anchor = yy_acpt[yy_last_accept_state];
                        if (0 != (YY_END & yy_anchor))
                        {
                            yy_move_end();
                        }
                        yy_to_mark();
                        switch (yy_last_accept_state)
                        {
                            case 1:
                                break;
                            case -2:
                                break;
                            case 2:
                                { break; }
                            case -3:
                                break;
                            case 3:
                                { Position.Line += 1; Position.Column = 1; break; }
                            case -4:
                                break;
                            case 4:
                                { Position.Column += yytext().Length; break; }
                            case -5:
                                break;
                            case 5:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    Console.WriteLine(Position.LineNumber + ":" + Position.ColumnNumber + " " +
                                    "\tERROR: UNRECOGNISED TOKEN(" + yytext() + ")");
                                    break;
                                }
                            case -6:
                                break;
                            case 6:
                                {
                                    Position.setPosition(); Position.Column += 1;
                                    return new Symbol(sym.LPAREN,
                                        new PddlToken(Position.LineNumber, Position.ColumnNumber));
                                }
                            case -7:
                                break;
                            case 7:
                                {
                                    Position.setPosition(); Position.Column += 1;
                                    return new Symbol(sym.RPAREN,
                                        new PddlToken(Position.LineNumber, Position.ColumnNumber));
                                }
                            case -8:
                                break;
                            case 8:
                                {
                                    Position.setPosition(); Position.Column += 1;
                                    return new Symbol(sym.MINUS,
                                        new PddlToken(Position.LineNumber, Position.ColumnNumber));
                                }
                            case -9:
                                break;
                            case 9:
                                {
                                    Position.setPosition(); Position.Column += 1;
                                    return new Symbol(sym.COLON,
                                        new PddlToken(Position.LineNumber, Position.ColumnNumber));
                                }
                            case -10:
                                break;
                            case 10:
                                {
                                    Position.setPosition(); Position.Column += 1;
                                    return new Symbol(sym.QUESTION,
                                        new PddlToken(Position.LineNumber, Position.ColumnNumber));
                                }
                            case -11:
                                break;
                            case 11:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -12:
                                break;
                            case 12:
                                { Position.Line += 1; Position.Column = 1; break; }
                            case -13:
                                break;
                            case 13:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.NOT,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -14:
                                break;
                            case 14:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.AND,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -15:
                                break;
                            case 15:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.INIT,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -16:
                                break;
                            case 16:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.GOAL,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -17:
                                break;
                            case 17:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.TYPES,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -18:
                                break;
                            case 18:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.DEFINE,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -19:
                                break;
                            case 19:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.DOMAIN,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -20:
                                break;
                            case 20:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.EFFECT,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -21:
                                break;
                            case 21:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.EITHER,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -22:
                                break;
                            case 22:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.OBJECT,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -23:
                                break;
                            case 23:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.ACTION,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -24:
                                break;
                            case 24:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.TYPING,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -25:
                                break;
                            case 25:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.STRIPS,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -26:
                                break;
                            case 26:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.OBJECTS,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -27:
                                break;
                            case 27:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.PROBLEM,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -28:
                                break;
                            case 28:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.PARAMETERS,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -29:
                                break;
                            case 29:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.PREDICATES,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -30:
                                break;
                            case 30:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIERS,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -31:
                                break;
                            case 31:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.REQUIREMENTS,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -32:
                                break;
                            case 32:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.PRECONDITION,
                                        new PddlReservedWordToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -33:
                                break;
                            case 34:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    Console.WriteLine(Position.LineNumber + ":" + Position.ColumnNumber + " " +
                                    "\tERROR: UNRECOGNISED TOKEN(" + yytext() + ")");
                                    break;
                                }
                            case -34:
                                break;
                            case 35:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -35:
                                break;
                            case 36:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -36:
                                break;
                            case 37:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -37:
                                break;
                            case 38:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -38:
                                break;
                            case 39:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -39:
                                break;
                            case 40:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -40:
                                break;
                            case 41:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -41:
                                break;
                            case 42:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -42:
                                break;
                            case 43:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -43:
                                break;
                            case 44:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -44:
                                break;
                            case 45:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -45:
                                break;
                            case 46:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -46:
                                break;
                            case 47:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -47:
                                break;
                            case 48:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -48:
                                break;
                            case 49:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -49:
                                break;
                            case 50:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -50:
                                break;
                            case 51:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -51:
                                break;
                            case 52:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -52:
                                break;
                            case 53:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -53:
                                break;
                            case 54:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -54:
                                break;
                            case 55:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -55:
                                break;
                            case 56:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -56:
                                break;
                            case 57:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -57:
                                break;
                            case 58:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -58:
                                break;
                            case 59:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -59:
                                break;
                            case 60:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -60:
                                break;
                            case 61:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -61:
                                break;
                            case 62:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -62:
                                break;
                            case 63:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -63:
                                break;
                            case 64:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -64:
                                break;
                            case 65:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -65:
                                break;
                            case 66:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -66:
                                break;
                            case 67:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -67:
                                break;
                            case 68:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -68:
                                break;
                            case 69:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -69:
                                break;
                            case 70:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -70:
                                break;
                            case 71:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -71:
                                break;
                            case 72:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -72:
                                break;
                            case 73:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -73:
                                break;
                            case 74:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -74:
                                break;
                            case 75:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -75:
                                break;
                            case 76:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -76:
                                break;
                            case 77:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -77:
                                break;
                            case 78:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -78:
                                break;
                            case 79:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -79:
                                break;
                            case 80:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -80:
                                break;
                            case 81:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -81:
                                break;
                            case 82:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -82:
                                break;
                            case 83:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -83:
                                break;
                            case 84:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -84:
                                break;
                            case 85:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -85:
                                break;
                            case 86:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -86:
                                break;
                            case 87:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -87:
                                break;
                            case 88:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -88:
                                break;
                            case 89:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -89:
                                break;
                            case 90:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -90:
                                break;
                            case 91:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -91:
                                break;
                            case 92:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -92:
                                break;
                            case 93:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -93:
                                break;
                            case 94:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -94:
                                break;
                            case 95:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -95:
                                break;
                            case 96:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -96:
                                break;
                            case 97:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -97:
                                break;
                            case 98:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -98:
                                break;
                            case 99:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -99:
                                break;
                            case 100:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -100:
                                break;
                            case 101:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -101:
                                break;
                            case 102:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -102:
                                break;
                            case 103:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -103:
                                break;
                            case 104:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -104:
                                break;
                            case 105:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -105:
                                break;
                            case 106:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -106:
                                break;
                            case 107:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -107:
                                break;
                            case 108:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -108:
                                break;
                            case 109:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -109:
                                break;
                            case 110:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -110:
                                break;
                            case 111:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -111:
                                break;
                            case 112:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -112:
                                break;
                            case 113:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -113:
                                break;
                            case 114:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -114:
                                break;
                            case 115:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -115:
                                break;
                            case 116:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -116:
                                break;
                            case 117:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -117:
                                break;
                            case 118:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -118:
                                break;
                            case 119:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -119:
                                break;
                            case 120:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -120:
                                break;
                            case 121:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -121:
                                break;
                            case 122:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -122:
                                break;
                            case 123:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -123:
                                break;
                            case 124:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -124:
                                break;
                            case 125:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -125:
                                break;
                            case 126:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -126:
                                break;
                            case 127:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -127:
                                break;
                            case 128:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -128:
                                break;
                            case 129:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -129:
                                break;
                            case 130:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -130:
                                break;
                            case 131:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -131:
                                break;
                            case 132:
                                {
                                    Position.setPosition(); Position.Column += yytext().Length;
                                    return new Symbol(sym.IDENTIFIER,
                                        new PddlIdentifierToken(yytext(), Position.LineNumber, Position.ColumnNumber));
                                }
                            case -132:
                                break;
                            default:
                                yy_error(YY_E_INTERNAL, false); break;
                        }
                        yy_initial = true;
                        yy_state = yy_state_dtrans[yy_lexical_state];
                        yy_next_state = YY_NO_STATE;
                        yy_last_accept_state = YY_NO_STATE;
                        yy_mark_start();
                        yy_this_accept = yy_acpt[yy_state];
                        if (YY_NOT_ACCEPT != yy_this_accept)
                        {
                            yy_last_accept_state = yy_state;
                            yy_mark_end();
                        }
                    }
                }
            }
        }
    }
}